
# @title 2.1&nbsp;Imports
from nltk.corpus import stopwords
from wordcloud import WordCloud

import matplotlib.pyplot as plt
import plotly.express as px
import pandas as pd
import numpy as np
import os
import csv
import json
import nltk
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.utils.multiclass import unique_labels
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error ,r2_score


# Codigo para que la parte interactiva se vea en el HTML

import plotly.io as pio
pio.renderers.default='notebook'


# @title 2.2&nbsp;Exportación de Drive
from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive


# @title 2.3&nbsp;Carga de DataFrames
df_games = pd.read_csv('/content/drive/MyDrive/CC5205/games.csv', encoding="UTF-8")
df_steam_reviews = pd.read_csv('/content/drive/MyDrive/CC5205/steam_reviews.csv', encoding="UTF-8", nrows=12043389)


# @title 2.4&nbsp; WordCloud

# Asegurarse de que la columna 'release_date' esté en formato de fecha
df_games['release_date'] = pd.to_datetime(df_games['release_date'], errors='coerce')

# Extraer el año de la fecha de lanzamiento
df_games['year'] = df_games['release_date'].dt.year

# Filtrar los datos para eliminar aquellos sin año de lanzamiento válido
df_games = df_games.dropna(subset=['year'])

# Obtener los años únicos y ordenarlos
years = sorted(df_games['year'].unique())

# Crear una nube de palabras para cada año
for year in years:
    # Filtrar los juegos por año
    juegos_ano = df_games[df_games['year'] == year]

    # Crear un diccionario para contar las frecuencias de cada género
    genero_frecuencias = {}

    # Contar las frecuencias de cada género
    for generos in juegos_ano['genres']:
        if pd.notna(generos):  # Verificar que no sea NaN
            for genero in generos.split(','):
                genero = genero.strip()  # Quitar espacios en blanco alrededor
                if genero in genero_frecuencias:
                    genero_frecuencias[genero] += 1
                else:
                    genero_frecuencias[genero] = 1

    # Generar la nube de palabras usando las frecuencias
    wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies(genero_frecuencias)

    # Mostrar la nube de palabras
    plt.figure(figsize=(10, 5))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.title(f'Nube de Palabras de Géneros para el Año {int(year)}')
    plt.axis('off')  # Desactivar los ejes
    plt.show()


# @title 2.5&nbsp;Diagrama de Dispersión
# Crear el scatter plot
fig_scatter = px.scatter(df_games,
                         x='price',
                         y='recommendations',
                         color='metacritic_score',
                         title='Scatter Plot: Precio vs Número Total de Reseñas',
                         labels={'price': 'Precio (USD)', 'recommendations': 'Número Total de Recomendaciones'})

fig_scatter.show()


# @title 2.6&nbsp;Diagrama de Dispersión con límites

# Crear el scatter plot
fig_scatter = px.scatter(df_games,
                         x='price',
                         y='recommendations',
                         color='metacritic_score',
                         title='Scatter Plot: Precio vs Número Total de Reseñas',
                         labels={'price': 'Precio (USD)', 'recommendations': 'Número Total de Recomendaciones'},
                         range_x=[0,100],
                         range_y=[1,1000000])

fig_scatter.show()


# @title 2.7&nbsp;Histograma de tiempo de juego por rango de precios

# Agrupa los datos por rango de precios
price_bins = [0, 10, 20, 30, 40, 50, 60, 70, 80]
df_games['price_range'] = pd.cut(df_games['price'], bins=price_bins)

# Calcula la media del tiempo de juego promedio para cada rango de precios
games_price_range = df_games.groupby('price_range')['average_playtime_forever'].mean().reset_index()

# Convierte el tiempo de juego de minutos a horas
games_price_range['average_playtime_forever'] = games_price_range['average_playtime_forever'] / 60

# Convierte los intervalos a cadenas
games_price_range['price_range'] = games_price_range['price_range'].astype(str)

# Crea el histograma
fig = px.bar(games_price_range, x='price_range', y='average_playtime_forever',
             title='Promedio de tiempo de juego por rango de precios',
             labels={'price_range': 'Rango de precios', 'average_playtime_forever': 'Promedio de tiempo de juego (horas)'},
             color_discrete_sequence=['orange'])

# Muestra el histograma
fig.show()


# @title 2.7&nbsp;WordCloud sobre palabras presentes en reseñas de juegos del género "Farming sim"

# Descargar stopwords en inglés
nltk.download('stopwords')
english_stopwords = set(stopwords.words('english'))

# Agregar las palabras específicas a las stopwords
custom_stopwords = {'game', 'really', 'play', 'like', 'thing', 'would', 'get', 'one', 'even', 'good', 'want', "I'm", 'much', 'make', 'still'}
all_stopwords = english_stopwords.union(custom_stopwords)

df_jrpg = df_games[df_games['tags'].str.contains('Farming Sim', na=False)]
id_jrpgs = df_jrpg['app_id']

df_steam_reviews_english = df_steam_reviews[(df_steam_reviews['language'] == 'english') & (df_steam_reviews['app_id'].isin(id_jrpgs))]

def create_word_cloud(reviews, title, max_words, stopwords):

    # Remover palabras vacías que no agregan nada al gráfico
    def remove_stopwords(text):
        words = text.split()
        filtered_words = [word for word in words if word.lower() not in stopwords]
        return ' '.join(filtered_words)

    cleaned_reviews = [remove_stopwords(review) for review in reviews]

    text = ' '.join(cleaned_reviews)

    wordcloud = WordCloud(width=800, height=400, max_words=max_words, background_color='white', stopwords=stopwords).generate(text)
    plt.figure(figsize=(8, 4))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.title(title + ' Word Cloud')
    plt.axis('off')
    plt.show()

positive_reviews = df_steam_reviews_english[df_steam_reviews_english['recommended'] == True]['review'].astype(str).sample(n=1000).tolist()
negative_reviews = df_steam_reviews_english[df_steam_reviews_english['recommended'] == False]['review'].astype(str).sample(n=1000).tolist()

create_word_cloud(positive_reviews, 'Reviews positivas para Farming simulator', 1000, all_stopwords)
create_word_cloud(negative_reviews, 'Reviews negativas para Farming simulator', 1000, all_stopwords)

[nltk_data] Downloading package stopwords to /root/nltk_data...
[nltk_data]   Unzipping corpora/stopwords.zip.


# @title &nbsp;
from sklearn.metrics import f1_score, recall_score, precision_score
from sklearn.model_selection import train_test_split
import numpy as np

def run_classifier(clf, X, y, num_tests=100):
    metrics = {'precision': [], 'recall': [], 'f1-score': []}

    for _ in range(num_tests):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.30, random_state=15, stratify=y)

        clf.fit(X_train, y_train)
        predictions = clf.predict(X_test)

        metrics['precision'].append(precision_score(y_test, predictions,average='weighted', zero_division=0))
        metrics['recall'].append(recall_score(y_test, predictions, average='weighted', zero_division=0))
        metrics['f1-score'].append(f1_score(y_test, predictions, average='weighted', zero_division=0))
    return metrics


# @title &nbsp;Clasificadores elegidos
from sklearn.dummy import DummyClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB  # naive bayes
from sklearn.neighbors import KNeighborsClassifier #kNN
from sklearn.svm import SVC  # support vector machine

c0 = ("Base Dummy", DummyClassifier(strategy='stratified'))
c1 = ("Decision Tree", DecisionTreeClassifier(max_depth=5))
c2 = ("Gaussian Naive Bayes", GaussianNB())
c3 = ("KNN", KNeighborsClassifier(n_neighbors=10))
#c4 = ("Support Vector Machines", SVC())

classifiers = [c0, c1, c2, c3]


# @title &nbsp;Predicción de la cantidad de dueños basándose en el precio y la puntuación en Metacritic
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

#separando atributos predictivos (X) del atributo objetivo (y)
X = data_filtered[['price','metacritic_score']].values
y = data_filtered['estimated_owners'].values

results = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X, y)   # hay que implementarla en el bloque anterior.
    results[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45293180402442973
Recall promedio: 0.45299701867252473
F1-score promedio: 0.4529592467956489
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.6047336565639093
Recall promedio: 0.7040640200847325
F1-score promedio: 0.6394325825118907
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.5723978257617705
Recall promedio: 0.5142397614938021
F1-score promedio: 0.5001481621798194
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6050389965558003
Recall promedio: 0.7016318845127886
F1-score promedio: 0.635961224535507
----------------


# @title &nbsp;Matriz de confusión
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import numpy as np
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Filtramos las clases válidas
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

# Separando atributos predictivos (X) del atributo objetivo (y)
X = data_filtered[['price', 'metacritic_score']].values
y = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=15, stratify=y)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()


# @title &nbsp;Predicción de la cantidad de dueños basándose en el precio y las reseñas positivas
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X1 = data_filtered[['price','positive']].values
y1 = data_filtered['estimated_owners'].values

results1 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X1, y1)   # hay que implementarla en el bloque anterior.
    results1[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.4530556807642149
Recall promedio: 0.45343009571630305
F1-score promedio: 0.4532378235864337
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.7497584274632675
Recall promedio: 0.7819708143731368
F1-score promedio: 0.7573347346223646
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.2627310747470592
Recall promedio: 0.24435116899419415
F1-score promedio: 0.1579333562389433
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.7366627779636193
Recall promedio: 0.7740467597677704
F1-score promedio: 0.7487414539848498
----------------


# @title &nbsp;Matriz de confusión
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X1 = data_filtered[['price','positive']].values
y1 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X1, y1, test_size=0.30, random_state=15, stratify=y1)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()


# @title &nbsp;Predicción de la cantidad de dueños basándose en la fecha de lanzamiento y las recomendaciones

# Hacemos una copia del DataFrame original
df_games_copy = df_games.copy()

# Convertimos la columna release_date a datetime
df_games_copy['release_date'] = pd.to_datetime(df_games_copy['release_date'], errors='coerce')

# Extraemos características numéricas de la fecha
df_games_copy['year'] = df_games_copy['release_date'].dt.year
df_games_copy['month'] = df_games_copy['release_date'].dt.month
df_games_copy['day'] = df_games_copy['release_date'].dt.day

# Filtramos las clases válidas
class_counts = df_games_copy['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games_copy[df_games_copy['estimated_owners'].isin(valid_classes)]

# Eliminamos las filas con NaN en las características seleccionadas
data_filtered = data_filtered.dropna(subset=['year', 'month', 'day', 'recommendations'])

# Preparamos las características y la variable objetivo
X2 = data_filtered[['year', 'month', 'day', 'recommendations']].values
y2 = data_filtered['estimated_owners'].values

results2 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X2, y2)   # hay que implementarla en el bloque anterior.
    results2[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45303906592942894
Recall promedio: 0.453051545582928
F1-score promedio: 0.4530403169242495
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.616086940999507
Recall promedio: 0.6820178879648516
F1-score promedio: 0.6055770806871238
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.12177468346275867
Recall promedio: 0.2011611485956379
F1-score promedio: 0.09135724986895451
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6166905569975587
Recall promedio: 0.6709948219049114
F1-score promedio: 0.62973466092412
----------------


# @title &nbsp;Matriz de confusión
# Hacemos una copia del DataFrame original
df_games_copy = df_games.copy()

# Convertimos la columna release_date a datetime
df_games_copy['release_date'] = pd.to_datetime(df_games_copy['release_date'], errors='coerce')

# Extraemos características numéricas de la fecha
df_games_copy['year'] = df_games_copy['release_date'].dt.year
df_games_copy['month'] = df_games_copy['release_date'].dt.month
df_games_copy['day'] = df_games_copy['release_date'].dt.day

# Filtramos las clases válidas
class_counts = df_games_copy['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games_copy[df_games_copy['estimated_owners'].isin(valid_classes)]

# Eliminamos las filas con NaN en las características seleccionadas
data_filtered = data_filtered.dropna(subset=['year', 'month', 'day', 'recommendations'])

# Preparamos las características y la variable objetivo
X2 = data_filtered[['year', 'month', 'day', 'recommendations']].values
y2 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X2, y2, test_size=0.30, random_state=15, stratify=y2)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()


# @title &nbsp;Predicción de la cantidad de dueños basándose en reseñas positivas y negativas
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X3 = data_filtered[['positive','negative']].values
y3 = data_filtered['estimated_owners'].values

results3 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X3, y3)   # hay que implementarla en el bloque anterior.
    results3[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45296304648569724
Recall promedio: 0.4532806370626078
F1-score promedio: 0.4531167358785427
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.7029434610039946
Recall promedio: 0.7033971442021025
F1-score promedio: 0.68788219727119
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.10356141353952113
Recall promedio: 0.2256786442805586
F1-score promedio: 0.1153237190476415
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6975135052229418
Recall promedio: 0.6999450808096661
F1-score promedio: 0.6850103852704434
----------------


# @title &nbsp;Matriz de confusión
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X3 = data_filtered[['positive','negative']].values
y3 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X3, y3, test_size=0.30, random_state=15, stratify=y3)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()


# @title &nbsp;Preprocesamiento

def preprocessing(dataframe, genre, begin_year = 1997, target_year = 2025):
  # Asegurarse de que la columna 'release_date' esté en formato de fecha
  dataframe['release_date'] = pd.to_datetime(dataframe['release_date'], errors='coerce')

  # Extraer el año de la fecha de lanzamiento
  dataframe['year'] = dataframe['release_date'].dt.year
  dataframe = dataframe[(dataframe['year'] >= begin_year) & (target_year >= dataframe['year'])]

  # Filtrar los datos para eliminar aquellos sin año de lanzamiento válido
  dataframe = dataframe.dropna(subset=['year'])
  # Extraemos los géneros
  dataframe = dataframe[dataframe['genres'].str.contains(genre, na=False)]
  result = dataframe.sort_values(by=["year"])[["year","genres"]]

  instances = result.groupby("year")

  # grupos [[años],[cantidades]]
  groups = [[],[]]
  for a, b in instances:
    groups[0].append(a)
    groups[1].append(b["genres"].size)
  #print(len(groups[0]))
  #print(len(groups[1]))
  final_result = pd.DataFrame({"year": groups[0], "quantity": groups[1]})
  return final_result


# @title &nbsp;Gráfico cantidad de juegos por género "Action" a través de los años
test1 = preprocessing(df_games, "Action")


X = []
y = []

X.extend(test1['year'].values)
y.extend(test1['quantity'].values)

X = np.array(X).reshape(-1, 1)
y = np.array(y).reshape(-1, 1)
plt.xlabel('Años')
plt.ylabel('Cantidad de juegos"')
plt.title('Cantidad de juegos por género "Action" a través de los años')
plt.scatter(X, y)
plt.show()


# @title &nbsp;Gráfico cantidad de juegos por género "Action" a través de los años restringidos
test2 = preprocessing(df_games, "Action", 2013, 2023)


X = []
y = []

X.extend(test2['year'].values)
y.extend(test2['quantity'].values)

X = np.array(X).reshape(-1, 1)
y = np.array(y).reshape(-1, 1)
plt.xlabel('Años')
plt.ylabel('Cantidad de juegos"')
plt.title('Cantidad de juegos por género "Action" entre 2013 y 2023')
plt.scatter(X, y)
plt.show()


# @title &nbsp;Experimento (regresión lineal)
# Supongamos que tus archivos se llaman 'data1.csv', 'data2.csv', ..., 'data10.csv'
# resultadosHeap/Fib

def fitting(dataframe, x_column, y_column, begin_year, target_year):
  # Creamos una lista para almacenar los resultados de cada regresión lineal
  X = []
  y = []

  # Definimos nuestras variables independientes y dependientes
  X.extend(dataframe[x_column].values) #independiente año
  y.extend(dataframe[y_column].values) #dependiente cantidad de juegos por el genero pedido

  X = np.array(X).reshape(-1, 1)
  y = np.array(y).reshape(-1, 1)

  # Creamos una instancia de la clase LinearRegression
  regressor = LinearRegression()

  # Entrenamos nuestro modelo con los datos de entrenamiento
  regressor.fit(X, y)

  # Almacenamos los resultados
  resultados = (regressor.coef_[0][0], regressor.intercept_[0])

  pendiente = resultados[0]
  intercepto = resultados[1]

  # Creamos un array de valores x basado en los datos originales
  x_plot = np.linspace(begin_year, target_year)
  # Calculamos los valores y usando la ecuación de la línea
  y_plot = pendiente * x_plot + intercepto

  print("Valor estimado para " + str(target_year) + ": " + str(pendiente * target_year + intercepto))
  print("Error absoluto medio:", mean_absolute_error(y, regressor.predict(X)))
  print("Coeficiente de determinación (R^2):", r2_score(y, regressor.predict(X)))

  plt.xlabel('Años')
  plt.ylabel('Cantidad de juegos')
  plt.title('Regresión lineal para la cantidad de juegos' + '\n' +  'por género "Action" entre ' + str(begin_year) + ' y ' + str(target_year))

  plt.scatter(X, y)
  plt.plot(x_plot, y_plot, color='red')
  plt.show()

  return resultados


# @title &nbsp;Gráfico regresión lineal cantidad de juegos por género "Action" a través de los años
fitting1 = fitting(test1, "year", "quantity", 1997, 2025)
print('')
fitting2= fitting(test2, "year", "quantity", 2013, 2025)

Valor estimado para 2025: 3171.744827586226
Error absoluto medio: 1014.5130966536456
Coeficiente de determinación (R^2): 0.45026782143598865

Valor estimado para 2025: 6820.518181818072
Error absoluto medio: 144.1818181817547
Coeficiente de determinación (R^2): 0.986741767958694


# @title &nbsp;Experimiento (regresión exponencial)

def fittingExpNormalized(dataframe, x_column, y_column, begin_year, target_year):
  # Creamos una lista para almacenar los resultados de cada regresión lineal
  X = dataframe[x_column].values
  y = dataframe[y_column].values

  # Normalizamos los años para evitar problemas de desbordamiento
  X_normalized = (X - np.mean(X)) / np.std(X)

  # Tomamos el logaritmo de y
  y_log = np.log(y)

  # Creamos una instancia de la clase LinearRegression
  regressor = LinearRegression()

  # Entrenamos nuestro modelo con los datos de entrenamiento
  regressor.fit(X_normalized.reshape(-1, 1), y_log.reshape(-1, 1))

  # Almacenamos los resultados
  pendiente = regressor.coef_[0][0]
  intercepto = regressor.intercept_[0]

  # Creamos un array de valores x basado en los datos originales
  x_plot = np.linspace(begin_year, target_year, 100)
  x_plot_normalized = (x_plot - np.mean(X)) / np.std(X)

  # Calculamos los valores y usando la ecuación de la línea
  y_plot = np.exp(intercepto) * np.exp(pendiente * x_plot_normalized)

  y_log_pred = regressor.predict(X_normalized.reshape(-1, 1))
  y_pred = np.exp(y_log_pred)
  mae_original = mean_absolute_error(y, y_pred)

  print("Valor estimado para " + str(target_year) + ": " + str(np.exp(intercepto) * np.exp(pendiente * (target_year - np.mean(X)) / np.std(X))))
  print("Error absoluto medio:",mae_original)
  print("Coeficiente de determinación (R^2):", r2_score(y, y_pred))

  plt.xlabel('Años')
  plt.ylabel('Cantidad de juegos')
  plt.title('Regresión exponencial para la cantidad de juegos' + '\n' + 'por género "Action" entre ' + str(begin_year) + ' y ' + str(target_year))
  plt.scatter(X, y)
  plt.plot(x_plot, y_plot, color='red')
  plt.show()

  return (pendiente, intercepto)


# @title &nbsp;Gráfico regresión lineal cantidad de juegos por género "Action" a través de los años restringidos
fitting1 = fittingExpNormalized(test1, "year", "quantity", 1997, 2025)
print('')
test3 = preprocessing(df_games, "Action", 1997, 2023)
fitting3 = fittingExpNormalized(test3, "year", "quantity", 1997, 2025)
print('')
fitting2 = fittingExpNormalized(test2, "year", "quantity", 2013, 2025)

Valor estimado para 2025: 3961.5252809066546
Error absoluto medio: 1077.242431970045
Coeficiente de determinación (R^2): 0.014076494783377913

Valor estimado para 2025: 29187.729019722865
Error absoluto medio: 706.374517885078
Coeficiente de determinación (R^2): 0.02550310201499939

Valor estimado para 2025: 14614.965472725622
Error absoluto medio: 789.8463072633757
Coeficiente de determinación (R^2): 0.5943960592235875


# @title &nbsp;Preprocesamiento

import pandas as pd
import numpy as np

# Eliminar filas con valores nulos en columnas críticas
df_games.dropna(subset=['price', 'genres', 'release_date'], inplace=True)

# Filtrar filas donde 'positive', 'negative' y recommendations sean mayores que 0
df_games = df_games[(df_games['positive'] > 0) & (df_games['negative'] > 0) & (df_games['recommendations'] > 0)]

# Filtrar datos relevantes
df_games = df_games[['app_id', 'name', 'genres', 'price', 'positive', 'negative', 'recommendations']]

# Obtener género principal
df_games['main_genre'] = df_games['genres'].apply(lambda x: x.split(',')[0].strip())

df_games


# @title &nbsp;PCA
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

X = df_games[['price', 'positive', 'negative', 'recommendations']]

# Escriba su código aquí
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Visualizar los datos
plt.scatter(X_pca[:, 0], X_pca[:, 1])
plt.show()


# @title &nbsp;Eligiendo el número de clusters óptimo
from sklearn.cluster import KMeans

# Escriba su código aquí
sse = []

clusters = list(range(1, 16))
for k in clusters:
    kmeans = KMeans(n_clusters=k, n_init='auto').fit(X_pca)
    sse.append(kmeans.inertia_)

plt.plot(clusters, sse, marker="o")
plt.title("Metodo del codo, desde 1 hasta 15 clusters")
plt.grid(True)
plt.show()


# @title &nbsp;K-means
random_state = 20

kmeans_4 = KMeans(n_clusters=4, n_init='auto', random_state=random_state).fit(X_pca)

centers_4 = kmeans_4.cluster_centers_

labels = kmeans_4.labels_

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=kmeans_4.labels_)
plt.scatter(centers_4[:,0], centers_4[:,1], s=200, facecolors='none', edgecolors='r')
plt.title("K-Means")
plt.show()


# @title &nbsp;
# Añade las etiquetas de los clusters al DataFrame original
df_games['cluster'] = labels

# Asigna nombres a los clusters basados en el análisis
cluster_names = {
    0: "Test0",
    1: "Test1",
    2: "Test2",
    3: "Test3"
}

# Mapea los nombres de los clusters a las etiquetas
df_games['cluster_name'] = df_games['cluster'].map(cluster_names)

# Mostrar ejemplos de cada cluster
for name, group in df_games.groupby('cluster_name'):
    print(f"Cluster: {name}")
    print(group[['name', 'main_genre', 'price', 'positive', 'negative', 'recommendations']].head())
    print("\n")

Cluster: Test0
                             name             main_genre  price  positive  \
10                         WARSAW                  Indie  23.99       589   
15         Alien Breed 3: Descent                 Action   9.99       349   
17         Hero of the Kingdom II              Adventure   7.99      2046   
22  Aerofly FS 2 Flight Simulator                 Action  37.49      1490   
24            Kanjozoku Game レーサー  Massively Multiplayer   5.99       392   

    negative  recommendations  
10       212              427  
15       134              285  
17       120             1615  
22       408             1831  
24        57              493  


Cluster: Test1
                                   name main_genre  price  positive  negative  \
46158  Counter-Strike: Global Offensive     Action    0.0   5764420    766677   

       recommendations  
46158          3441592  


Cluster: Test2
                                 name main_genre  price  positive  negative  \
1289                      Garry's Mod      Indie   9.99    822326     29004   
2904  Tom Clancy's Rainbow Six® Siege     Action  19.99    312232     64137   
4287  Tom Clancy's Rainbow Six® Siege     Action  19.99    312816     64201   
5993            ARK: Survival Evolved     Action  29.99    461567     98701   
8009                   Cyberpunk 2077        RPG  59.99    391643    129925   

      recommendations  
1289           725462  
2904           899435  
4287           899455  
5993           435328  
8009           458744  


Cluster: Test3
                         name main_genre  price  positive  negative  \
47                 Far Cry® 5     Action  59.99    100620     25286   
57            Forza Horizon 4     Racing  59.99    122539     15095   
96        Oxygen Not Included      Indie  24.99     82902      3014   
736             Apex Legends™     Action   0.00    415524     66608   
828  American Truck Simulator      Indie  19.99    104521      3859   

     recommendations  
47            114588  
57            126316  
96             80467  
736             1000  
828            87888


# @title &nbsp;Sample

# Muestreo aleatorio del 10% de los datos
sample_fraction = 0.1
df_sample = df_games.sample(frac=sample_fraction, random_state=42)
X_sample = df_sample[['price', 'positive', 'negative', 'recommendations']]
X_sample_pca = pca.transform(X_sample)


# @title &nbsp;
from scipy.cluster.hierarchy import dendrogram, linkage

complete = linkage(X_sample, method="complete")
single = linkage(X_sample, method="single")
average = linkage(X_sample, method="average")
ward = linkage(X_sample, method="ward")


# @title &nbsp;
dendrogram(ward)
plt.title("Linkage: Ward")
plt.show()


# @title &nbsp;
dendrogram(ward)
plt.title("Linkage: Ward")
plt.axhline(y=400000, color='r', linestyle='--')
plt.show()


# @title &nbsp;
from sklearn.cluster import AgglomerativeClustering

# Escriba su código aquí
ward_all = AgglomerativeClustering(n_clusters=None, linkage="ward", distance_threshold=400000).fit(X_sample_pca)
print(ward_all.n_clusters_)

3


# @title &nbsp;
plt.scatter(X_sample_pca[:, 0], X_sample_pca[:, 1], c=ward_all.labels_)
plt.title("Hierarchical: ward, 3 clusters")
plt.show()


# @title &nbsp;
from sklearn.neighbors import NearestNeighbors
import numpy as np

nbrs = NearestNeighbors(n_neighbors=3).fit(X_sample)
distances, indices = nbrs.kneighbors(X_sample)

distances = np.sort(distances, axis=0)
distances = distances[:,1]

fig, ax = plt.subplots()

ax.axhline(y=5000, color='r', linestyle='--') # Ajuste el valor para y
ax.plot(distances)

plt.show()


# @title &nbsp;
from sklearn.cluster import DBSCAN

eps = 5000
min_samples = 5

dbscan = DBSCAN(eps=eps, min_samples=min_samples).fit(X_sample_pca)
plt.scatter(X_sample_pca[:,0], X_sample_pca[:,1], c=dbscan.labels_)
plt.title(f"DBSCAN: eps={eps}, min_samples={min_samples}")
plt.show()


# @title &nbsp;Coeficiente de Silhouette
from sklearn.metrics import silhouette_score

print("Dataset X K-Means 4\t", silhouette_score(X_pca, kmeans_4.labels_))

print("Dataset X ward all\t", silhouette_score(X_sample_pca, ward_all.labels_))

_filter_label = dbscan.labels_ >= 0
print("Dataset X DBSCAN\t", silhouette_score(X_sample_pca[_filter_label], dbscan.labels_[_filter_label]))

Dataset X K-Means 4	 0.9552412648896319
Dataset X ward all	 0.9199589324743636
Dataset X DBSCAN	 0.906227566420273

Hito 3: Estudio de las recomendaciones de Steam¶

1. Introducción

1.1 ¿Qué es Steam?

1.2 Motivación

2. Exploración de Datos

3. Preguntas y problemas

Pregunta 1 (Clasificadores)¶

¿Qué parámetros influyen más en la cantidad de ventas totales?¶

Pregunta 2 (Regresión)¶

¿Se puede predecir la cantidad de juegos con género "X" que habrán en un año determinado?¶

Pregunta 3 (Clustering)¶

¿Es posible identificar grupos de juegos (según precio o número de reviews positivas, por ejemplo) que ayuden a entender las características comunes de juegos exitosos o populares?¶

4. Experimentación y resultados

Pregunta 1¶

Conclusión¶

Pregunta 2¶

Un primer acercamiento¶

¿Existirá otro tipo de regresión para analizar estos datos?¶

Conclusión¶

Pregunta 3¶

Conclusión¶

Planificación futura¶

Contribuciones¶

Contribuciones de cada integrante Hito 1¶

Contribuciones de cada integrante Hito 2¶

Contribuciones de cada integrante Hito 3¶

Anexos¶

	app_id	name	genres	price	positive	negative	recommendations	main_genre
10	1026420	WARSAW	Indie,RPG	23.99	589	212	427	Indie
15	22670	Alien Breed 3: Descent	Action	9.99	349	134	285	Action
17	346560	Hero of the Kingdom II	Adventure,Casual,Indie,RPG	7.99	2046	120	1615	Adventure
22	434030	Aerofly FS 2 Flight Simulator	Action,Indie,Racing,Simulation	37.49	1490	408	1831	Action
24	2073470	Kanjozoku Game レーサー	Massively Multiplayer,Racing,Simulation,Sports	5.99	392	57	493	Massively Multiplayer
...	...	...	...	...	...	...	...	...
84311	2152790	UNITED 1944	Action,Early Access	23.99	160	30	179	Action
84325	2052410	WITCH ON THE HOLY NIGHT	Adventure	35.99	658	13	740	Adventure
84326	2287520	Five Nights at Freddy's: Help Wanted 2	Indie,Simulation	39.99	862	84	1067	Indie
84454	2499800	Garten of Banban 6	Action,Adventure,Casual,Indie	9.99	280	123	403	Action
84963	2487350	Alex Jones: NWO Wars	Action,Indie	17.76	596	32	780	Action